import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import '../services/dio_service.dart';
import '../models/index.dart';
import '../utils/encryption_util.dart';
import 'dart:convert';

/// 积分相关API
/// 
/// 负责所有积分相关的API调用
/// 使用DioService进行网络请求，使用AES加密
class PointsApi {
  // 📡 网络服务实例
  static DioService get _dioService => Get.find<DioService>();
  
  /// 获取积分套餐列表
  /// 根据接口文档 5.1 获取积分套餐列表
  /// POST /api/points/packages/
  static Future<PointsPackageResponse> getPointsPackages() async {
    try {
      debugPrint('🔄 =============== 开始获取积分套餐列表（AES加密） ===============');

      // 创建加密载荷（空数据也需要加密）
      final encryptedPayload = EncryptionUtil.createEncryptedPayload({});
      
      debugPrint('🚀 准备发送加密请求到: /api/points/packages/');
      debugPrint('📦 请求载荷: ${encryptedPayload.toString()}');

      final response = await _dioService.post(
        '/api/points/packages/',
        data: encryptedPayload,
      );

      debugPrint('📨 服务器响应: ${response.data}');

      // 尝试解析响应
      final packageResponse = PointsPackageResponse.fromJson(
        response.data is Map<String, dynamic> 
            ? response.data as Map<String, dynamic> 
            : {'status': 'error', 'message': '响应格式错误', 'packages': []}
      );
      
      debugPrint('✅ 积分套餐列表获取成功（AES加密）');
      debugPrint('🏁 =============== 积分套餐获取完成 ===============');

      return packageResponse;
    } catch (e) {
      debugPrint('💥 获取积分套餐列表异常: $e');
      
      // 返回错误响应
      return PointsPackageResponse(
        status: 'error',
        message: '获取积分套餐失败: ${e.toString()}',
        packages: [],
      );
    }
  }

  /// 创建支付宝支付订单
  /// 根据接口文档 5.2 创建支付宝支付订单
  /// POST /api/payment/alipay/create_app_order
  /// 🔐 必须使用AES加密
  static Future<Map<String, dynamic>> createAlipayOrder({
    required int userId,
    required int packageId,
  }) async {
    try {
      debugPrint('🔄 =============== 开始创建支付宝订单（AES加密） ===============');
      debugPrint('👤 用户ID: $userId, 📦 套餐ID: $packageId');

      // 创建请求数据
      final requestData = {
        'user_id': userId.toString(),  // 字符串格式
        'package_id': packageId,
      };
      
      debugPrint('📊 请求参数（加密前）: ${jsonEncode(requestData)}');
      debugPrint('📊 字段详情:');
      requestData.forEach((key, value) {
        debugPrint('   - $key: $value (${value.runtimeType})');
      });
      
      // 🔐 使用AES加密
      debugPrint('🔐 开始AES加密支付宝订单数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      debugPrint('🚀 准备发送加密请求到: /api/payment/alipay/create_app_order');
      debugPrint('📦 加密载荷: $encryptedPayload');

      final response = await _dioService.post(
        '/api/payment/alipay/create_app_order',
        data: encryptedPayload,
      );

      debugPrint('📨 服务器响应: ${response.data}');
      debugPrint('✅ 支付宝订单创建成功（AES加密）');
      debugPrint('🏁 =============== 支付订单创建完成 ===============');
      
      return response.data is Map<String, dynamic>
          ? response.data as Map<String, dynamic>
          : {'status': 'error', 'message': '响应格式错误'};
    } catch (e) {
      debugPrint('💥 创建支付宝订单异常: $e');
      return {
        'status': 'error',
        'message': '创建支付订单失败: ${e.toString()}',
      };
    }
  }

  /// 查询充值记录
  /// 根据接口文档 5.3 查询充值记录
  /// POST /api/payment/records/
  static Future<Map<String, dynamic>> getPaymentRecords({
    required int userId,
    int page = 1,
    int pageSize = 10,
  }) async {
    try {
      debugPrint('🔄 =============== 开始查询充值记录（AES加密） ===============');
      debugPrint('📊 用户ID: $userId, 页码: $page, 每页数量: $pageSize');

      // 创建加密载荷
      final requestData = {
        'user_id': userId.toString(),  // 转换为字符串
        'page': page,
        'page_size': pageSize,
      };
      
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      debugPrint('🚀 准备发送加密请求到: /api/payment/records/');
      debugPrint('📦 请求载荷: ${encryptedPayload.toString()}');

      final response = await _dioService.post(
        '/api/payment/records/',
        data: encryptedPayload,
      );

      debugPrint('📨 服务器响应: ${response.data}');
      debugPrint('✅ 充值记录查询成功（AES加密）');
      debugPrint('🏁 =============== 充值记录查询完成 ===============');
      
      return response.data is Map<String, dynamic>
          ? response.data as Map<String, dynamic>
          : {'status': 'error', 'message': '响应格式错误'};
    } catch (e) {
      debugPrint('💥 查询充值记录异常: $e');
      return {
        'status': 'error',
        'message': '查询充值记录失败: ${e.toString()}',
      };
    }
  }

  /// 查询用户积分变更历史（使用AES加密）
  /// 根据接口文档 5.6 查询用户积分变更历史
  /// POST /user/points/history
  static Future<PointsHistoryResponse> getPointsHistory({
    required int userId,
    int page = 1,
    int pageSize = 20,
    int? changeType, // 可选的变动类型过滤
  }) async {
    try {
      debugPrint('🔄 =============== 开始查询积分变更历史（AES加密） ===============');
      debugPrint('📊 用户ID: $userId (${userId.runtimeType}), 页码: $page, 每页数量: $pageSize');

      final requestData = {
        'userid': userId,  // 🔥 使用userid字段名，整数类型（按API文档要求）
        'page': page,
      };

      // 如果有变动类型筛选，添加到请求中
      if (changeType != null) {
        requestData['change_type'] = changeType;
        debugPrint('🔍 变动类型过滤: $changeType');
      }
      
      debugPrint('📊 请求参数（加密前）: ${jsonEncode(requestData)}');
      debugPrint('📊 字段详情:');
      requestData.forEach((key, value) {
        debugPrint('   - $key: $value (${value.runtimeType})');
      });
      
      // 🔥 使用AES加密
      debugPrint('🔐 开始AES加密积分历史查询数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      debugPrint('🚀 准备发送加密请求到: /user/points/history');

      final response = await _dioService.post(
        '/user/points/history',
        data: encryptedPayload,
      );

      debugPrint('📨 服务器响应: ${response.data}');
      debugPrint('✅ 积分变更历史查询成功（AES加密）');
      debugPrint('🏁 =============== 积分变更历史查询完成 ===============');
      
      // 解析响应
      final historyResponse = PointsHistoryResponse.fromJson(
        response.data is Map<String, dynamic>
            ? response.data as Map<String, dynamic>
            : {'status': 'error', 'message': '响应格式错误', 'history': []}
      );
      
      return historyResponse;
    } catch (e) {
      debugPrint('💥 查询积分变更历史异常: $e');
      return PointsHistoryResponse(
        status: 'error',
        message: '查询积分变更历史失败: ${e.toString()}',
        history: [],
      );
    }
  }

  /// 🔥 扣除用户积分（同步扣除）
  /// 
  /// 接口: POST /user/points/change
  /// 加密方式: AES-256-CBC
  /// 
  /// 在发布活动、加好友等操作时同步调用
  /// 与小程序保持一致，由后端直接扣除积分
  /// 
  /// [userId] 用户ID
  /// [points] 扣除的积分数（正数）
  /// [reason] 扣除原因（如："发布活动"、"加好友"）
  /// [relatedId] 关联的业务ID（活动ID、好友申请ID等，可选）
  /// 返回扣除结果（包含扣除后的剩余积分）
  static Future<Map<String, dynamic>> deductPoints({
    required int userId,
    required int points,
    required String reason,
    int? relatedId,
  }) async {
    try {
      debugPrint('💸 =============== 开始扣除用户积分（AES加密） ===============');
      debugPrint('👤 用户ID: $userId');
      debugPrint('💰 扣除积分: $points');
      debugPrint('📝 扣除原因: $reason');
      if (relatedId != null) debugPrint('🔗 关联ID: $relatedId');

      // 构建请求数据（按照API文档格式）
      final requestData = {
        'userid': userId,  // 🔥 修复：使用userid字段名，整数类型（按API文档要求）
        'points_change': -points,  // 🔥 负数表示扣除
        'change_type': 2,  // 🔥 2=消费
        'change_reason': reason,
        'operator': 'system',
      };

      // 添加关联ID（如果有）
      if (relatedId != null) {
        requestData['related_id'] = relatedId.toString();
      }
      
      debugPrint('📊 请求参数（加密前）: ${jsonEncode(requestData)}');
      debugPrint('📊 字段详情:');
      requestData.forEach((key, value) {
        debugPrint('   - $key: $value (${value.runtimeType})');
      });
      
      // 🔥 使用AES加密
      debugPrint('🔐 开始AES加密积分扣除数据...');
      final encryptedPayload = EncryptionUtil.createEncryptedPayload(requestData);
      
      debugPrint('🚀 准备发送加密请求到: /user/points/change');

      final response = await _dioService.post(
        '/user/points/change',
        data: encryptedPayload,
      );

      debugPrint('📨 服务器响应: ${response.data}');
      
      // 解析响应数据
      if (response.data != null && response.data is Map<String, dynamic>) {
        final responseData = response.data as Map<String, dynamic>;
        
        if (responseData['status'] == 'success') {
          debugPrint('✅ 积分扣除成功');
          debugPrint('💰 新积分: ${responseData['new_points'] ?? "未知"}');
          debugPrint('📝 日志ID: ${responseData['log_id'] ?? "未知"}');
          debugPrint('🏁 =============== 积分扣除完成 ===============');
          
          return {
            'status': 'success',
            'message': responseData['message'] ?? '积分扣除成功',
            'new_points': responseData['new_points'],  // 🔥 返回新积分
            'log_id': responseData['log_id'],
            'deducted_points': points,
          };
        } else {
          final errorMsg = responseData['message'] ?? '积分扣除失败';
          debugPrint('❌ 积分扣除失败: $errorMsg');
          return {
            'status': 'error',
            'message': errorMsg,
          };
        }
      } else {
        debugPrint('❌ 响应数据格式错误');
        return {
          'status': 'error',
          'message': '服务器响应格式错误',
        };
      }
    } catch (e) {
      debugPrint('💥 扣除积分异常: $e');
      return {
        'status': 'error',
        'message': '扣除积分失败: ${e.toString()}',
      };
    }
  }
}

